

    /////////////////////////////////////////////////
    
    Parent.implement
    (
        
        /**
         * Set the value property to any value.
         * 
         * @param {Object} value
         * @return {void}
         * 
         * @see #getValue
         */
        function setValue (value) 
        {
            this.value= value;
        }
        
        /**
         * Retrieve the value property previously set by #setValue
         * @return {Object}
         * 
         * @see #setValue
         */
    ,   function getValue () 
        {
            return this.value;
        }
    );
    
    function Parent () {;};
    
    /////////////////////////////////////////////////
    
    Child.inherit(Parent).implement
    (
        
        /**
         * Set the objects value property to any string value.
         * 
         * @override
         * @param {String} value  Any string value
         * @return {void}
         * @throws {TypeError}    A TypeError is thrown if value is not a string.
         */
        function setValue (value) 
        {
            // implement a gaurd clause that will only accept strings
            if (false === String.type(value))
                throw new TypeError;
            
            // invoke the Parent.prototype.setValue implementation 
            this.parent.setValue.call(this, value);
        }
    );
    
    /**
     * Create a new instance of child, providing it with a string value.
     * 
     * @constructor
     * @param {String} value    Any string value
     * @throws {TypeError}      A type error is thrown if value is not a string.
     */
    function Child (value) 
    {
        this.setValue(value);
    };
    
    /////////////////////////////////////////////////
    
    Specialized.inherit(Child);
    
    /**
     * Create a new specialized instance.
     * @constructor
     */
    function Specialized () 
    {
        // invoke this classes parent constructor- because of the instantiation
        // logic in Child, Child.prototype.setValue is invoked, and supplied
        // with 'presetValue' as the sole argument
        Child.call(this, 'presetValue');
    };
    
    
    /*
     * It would be great if rather than having to reference an objects
     * super constructor by name, that we could reference it via the 
     * parent property like so. 
     * 
     *     function Superclass () 
     *     {
     *         // do stuff here
     *     };
     *     
     *     Subclass.inherit(Superclass);
     *     function Superclass () 
     *     {
     *         this.parent.constructor.apply(this, arguments);
     *     };
     *     
     * If we were able to do this, we'd only have to take care of managing one
     * reference to the super constructor when we use the #inherit method,
     * but unfortunately, all JavaScript interpreters I know of encounter
     * recursion errors if super constructors are referenced indirectly like 
     * above. For that reason, if you want to apply a super constructors
     * instantiation logic to a subclass, you must reference it directly by name
     * as in the examples above.
     * 
     */
    